home *** CD-ROM | disk | FTP | other *** search
/ Scene Storm / Scene Storm - Volume 1.iso / coding / asm / misc / planarconversions / c2p_adaptive.s < prev    next >
Text File  |  1980-01-03  |  19KB  |  703 lines
  1.         xdef    _chunky2planar
  2.  
  3. ; peterm/adaptive.s
  4. ; Combines peterm/chunky4.s and jmccoull/blitter4pass.s
  5. ; The blitter works on the top portion of the display at the same time as
  6. ; the CPU converts the bottom portion.
  7. ; The blitter has completely finished before the routine returns.
  8. ; Both parts of every call are timed using the EClock.
  9. ; The partition point is recalculated at the end of the call in an attempt
  10. ; to keep the two routines taking about the same amount of time.
  11. ;
  12. ; The following formula is used:
  13. ;
  14. ;    n_blit = n * t_cpu * n_blit / (t_blit * n_cpu + t_cpu * n_blit)
  15. ;
  16. ; where:
  17. ;    n    is the total number of 32-byte units (i.e, width*height/32)
  18. ;    n_blit    is the number of 32-byte units above the partition
  19. ;    n_cpu    is the number of 32-byte units below the partition (=n-n_blit)
  20. ;    t_blit    is the time taken by the blitter in EClock units
  21. ;    t_cpu    is the time taken by the cpu in EClock units
  22. ;
  23. ; ECS Agnus required (for long blits)
  24.  
  25. bltcpt         equ    $048
  26. bltbpt         equ    $04c
  27. bltapt         equ    $050
  28. bltdpt         equ    $054
  29. bltsizv      equ    $05c
  30. bltsizh      equ    $05e
  31. cleanup        equ    $40
  32. _LVOReadEClock    equ    -60
  33.  
  34. ;-----------------------------------------------------------------------------
  35. ; chunky2planar:    (new Motorola syntax)
  36. ;  a0 -> chunky pixels (in FAST RAM)
  37. ;  a1 -> plane0 (assume other 7 planes are allocated contiguously)
  38. ;  a5 = TimerBase
  39. ;  a6 = GfxBase
  40.  
  41. width        equ    320        ; must be a multiple of 32
  42. height        equ    200
  43. pixels        equ    width*height
  44. plsiz        equ    (width/8)*height
  45.  
  46.  
  47.         section    code,code
  48.  
  49. _chunky2planar:    movem.l    d2-d7/a2-a6,-(sp)
  50.  
  51. ; save parameters
  52.  
  53.         movea.l    #mybltnode,a2
  54.         move.l    a0,(chunky-mybltnode,a2)
  55.         move.l    a1,(plane0-mybltnode,a2)
  56.         move.l    a5,(timerbase-mybltnode,a2)
  57.         move.l    a6,(gfxbase-mybltnode,a2)
  58.  
  59. ; copy pixels_blit from chunky to buff0 (from FAST to CHIP) for the blitter
  60.  
  61.         movea.l    (chunky-mybltnode,a2),a0
  62.         movea.l    #buff0,a1
  63.         move.l    (pixels_blit-mybltnode,a2),d0
  64.         movea.l    (4).w,a6
  65.         jsr    (_LVOCopyMemQuick,a6)
  66.  
  67. ; read the start time
  68.  
  69.         lea    (starttime-mybltnode,a2),a0
  70.         movea.l    (timerbase-mybltnode,a2),a6
  71.         jsr    (_LVOReadEClock,a6)
  72.  
  73. ; start the blitter in the background
  74.  
  75.         st    (waitflag-mybltnode,a2)
  76.         movea.l    a2,a1
  77.         movea.l    (gfxbase-mybltnode,a2),a6
  78.         jsr    (_LVOQBlit,a6)
  79.  
  80. ; compute starting parameters for the CPU routine
  81.  
  82.         move.l    #plsiz,d0
  83.         sub.l    (plsiz_blit-mybltnode,a2),d0
  84.         lsr.l    #2,d0
  85.         move.w    d0,-(sp)    ; outer loop counter on stack
  86.  
  87.         move.l    (chunky-mybltnode,a2),a0
  88.         adda.l    (pixels_blit-mybltnode,a2),a0    ; offset into chunky
  89.  
  90.         move.l    (plane0-mybltnode,a2),a1
  91.         adda.l    (plsiz_blit-mybltnode,a2),a1    ; offset into plane
  92.  
  93.         lea    (buffers-mybltnode,a2),a3    ; a3 -> buffers
  94.  
  95.     iflt 4*plsiz-4-32768
  96.         adda.w    #3*plsiz,a1    ; a1 -> plane 3
  97.     else
  98.     iflt 2*plsiz-4-32768
  99.         adda.w    #1*plsiz,a1    ; a1 -> plane 1
  100.     endc
  101.     endc
  102.  
  103. ; set up register constants
  104.  
  105.         move.l    #$0f0f0f0f,d5    ; d5 = constant $0f0f0f0f
  106.         move.l    #$55555555,d6    ; d6 = constant $55555555
  107.         move.l    #$3333cccc,d7    ; d7 = constant $3333cccc
  108.         lea    (4,a3),a2    ; used for inner loop end test
  109.  
  110. ; load up address registers with buffer ptrs
  111.  
  112.         lea    (2*4,a3),a4    ; a4 -> plane2buf
  113.         lea    (2*4,a4),a5    ; a5 -> plane4buf
  114.         lea    (2*4,a5),a6    ; a6 -> plane6buf
  115.  
  116. ; main loop (starts here) processes 8 chunky pixels at a time
  117.  
  118. mainloop:
  119.  
  120. ; d0 = a7a6a5a4a3a2a1a0 b7b6b5b4b3b2b1b0 c7c6c5c4c3c2c1c0 d7d6d5d4d3d2d1d0
  121.  
  122.         move.l    (a0)+,d0    ; 12 get next 4 chunky pixels in d0
  123.  
  124. ; d1 = e7e6e5e4e3e2e1e0 f7f6f5f4f3f2f1f0 g7g6g5g4g3g2g1g0 h7h6h5h4h3h2h1h0
  125.  
  126.         move.l    (a0)+,d1    ; 12 get next 4 chunky pixels in d1
  127.  
  128. ; d2 = d0 & 0f0f0f0f
  129. ; d2 = ........a3a2a1a0 ........b3b2b1b0 ........c3c2c1c0 ........d3d2d1d0
  130.  
  131.         move.l    d0,d2        ;  4
  132.         and.l    d5,d2        ;  8 d5=$0f0f0f0f
  133.  
  134. ; d0 ^= d2
  135. ; d0 = a7a6a5a4........ b7b6b5b4........ c7c6c5c4........ d7d6d5d4........
  136.  
  137.         eor.l    d2,d0        ;  8
  138.  
  139. ; d3 = d1 & 0f0f0f0f
  140. ; d3 = ........e3e2e1e0 ........f3f2f1f0 ........g3g2g1g0 ........h3h2h1h0
  141.  
  142.         move.l    d1,d3        ;  4
  143.         and.l    d5,d3        ;  8 d5=$0f0f0f0f
  144.  
  145. ; d1 ^= d3
  146. ; d1 = e7e6e5e4........ f7f6f5f4........ g7g6g5g4........ h7h6h5h4........
  147.  
  148.         eor.l    d3,d1        ;  8
  149.  
  150. ; d2 = (d2 << 4) | d3
  151. ; d2 = a3a2a1a0e3e2e1e0 b3b2b1b0f3f2f1f0 c3c2c1c0g3g2g1g0 d3d2d1d0h3h2h1h0
  152.  
  153.         lsl.l    #4,d2        ; 16
  154.         or.l    d3,d2        ;  8
  155.  
  156. ; d0 = d0 | (d1 >> 4)
  157. ; d0 = a7a6a5a4e7e6e5e4 b7b6b5b4f7f6f5f4 c7c6c5c4g7g6g5g4 d7d6d5d4h7h6h5h4
  158.  
  159.         lsr.l    #4,d1        ; 16
  160.         or.l    d1,d0        ;  8
  161.  
  162. ; d3 = ((d2 & 33330000) << 2) | (swap(d2) & 3333cccc) | ((d2 & 0000cccc) >> 2)
  163. ; d3 = a1a0c1c0e1e0g1g0 b1b0d1d0f1f0h1h0 a3a2c3c2e3e2g3g2 b3b2d3d2f3f2h3h2
  164.  
  165.         move.l    d2,d3        ;  4
  166.         and.l    d7,d3        ;  8 d7=$3333cccc
  167.         move.w    d3,d1        ;  4
  168.         clr.w    d3        ;  4
  169.         lsl.l    #2,d3        ; 12
  170.         lsr.w    #2,d1        ; 10
  171.         or.w    d1,d3        ;  4
  172.         swap    d2        ;  4
  173.         and.l    d7,d2        ;  8 d7=$3333cccc
  174.         or.l    d2,d3        ;  8
  175.  
  176. ; d1 = ((d0 & 33330000) << 2) | (swap(d0) & 3333cccc) | ((d0 & 0000cccc) >> 2)
  177. ; d1 = a5a4c5c4e5e4g5g4 b5b4d5d4f5f4h5h4 a7a6c7c6e7e6g7g6 b7b6d7d6f7f6h7h6
  178.  
  179.         move.l    d0,d1        ;  4
  180.         and.l    d7,d1        ;  8 d7=$3333cccc
  181.         move.w    d1,d2        ;  4
  182.         clr.w    d1        ;  4
  183.         lsl.l    #2,d1        ; 12
  184.         lsr.w    #2,d2        ; 10
  185.         or.w    d2,d1        ;  4
  186.         swap    d0        ;  4
  187.         and.l    d7,d0        ;  8 d7=$3333cccc
  188.         or.l    d0,d1        ;  8
  189.  
  190. ; d2 = d1 >> 7
  191. ; d2 = ..............a5 a4c5c4e5e4g5g4b5 b4d5d4f5f4h5h4a7 a6c7c6e7e6g7g6..
  192.  
  193.         move.l    d1,d2        ;  4
  194.         lsr.l    #7,d2        ; 22
  195.  
  196. ; d0 = d1 & 55555555
  197. ; d0 = ..a4..c4..e4..g4 ..b4..d4..f4..h4 ..a6..c6..e6..g6 ..b6..d6..f6..h6
  198.  
  199.         move.l    d1,d0        ;  4
  200.         and.l    d6,d0        ;  8 d6=$55555555
  201.  
  202. ; d1 ^= d0
  203. ; d1 = a5..c5..e5..g5.. b5..d5..f5..h5.. a7..c7..e7..g7.. b7..d7..f7..h7..
  204.  
  205.         eor.l    d0,d1        ;  8
  206.  
  207. ; d4 = d2 & 55555555
  208. ; d4 = ..............a5 ..c5..e5..g5..b5 ..d5..f5..h5..a7 ..c7..e7..g7....
  209.  
  210.         move.l    d2,d4        ;  4
  211.         and.l    d6,d4        ;  8 d6=$55555555
  212.  
  213. ; d2 ^= d4
  214. ; d2 = ................ a4..c4..e4..g4.. b4..d4..f4..h4.. a6..c6..e6..g6..
  215.  
  216.         eor.l    d4,d2        ;  8
  217.  
  218. ; d1 = (d1 | d4) >> 1
  219. ; d1 = ................ a5b5c5d5e5f5g5h5 ................ a7b7c7d7e7f7g7h7
  220.  
  221.         or.l    d4,d1        ;  8
  222.         lsr.l    #1,d1        ; 10
  223.  
  224.         move.b    d1,(4,a6)    ; 12 plane 7
  225.         swap    d1        ;  4
  226.         move.b    d1,(4,a5)    ; 12 plane 5
  227.  
  228. ; d2 |= d0
  229. ; d2 = ................ a4b4c4d4e4f4g4h4 ................ a6b6c6d6e6f6g6h6
  230.  
  231.         or.l    d0,d2        ;  8
  232.  
  233.         move.b    d2,(a6)+    ;  8 plane 6
  234.         swap    d2        ;  4
  235.         move.b    d2,(a5)+    ;  8 plane 4
  236.  
  237. ; d2 = d3 >> 7
  238. ; d2 = ..............a1 a0c1c0e1e0g1g0b1 b0d1d0f1f0h1h0a3 a2c3c2e3e2g3g2..
  239.  
  240.         move.l    d3,d2        ;  4
  241.         lsr.l    #7,d2        ; 22
  242.  
  243. ; d0 = d3 & 55555555
  244. ; d0 = ..a0..c0..e0..g0 ..b0..d0..f0..h0 ..a2..c2..e2..g2 ..b2..d2..f2..h2
  245.  
  246.         move.l    d3,d0        ;  4
  247.         and.l    d6,d0        ;  8 d6=$55555555
  248.  
  249. ; d3 ^= d0
  250. ; d3 = a1..c1..e1..g1.. b1..d1..f1..h1.. a3..c3..e3..g3.. b3..d3..f3..h3..
  251.  
  252.         eor.l    d0,d3        ;  8
  253.  
  254. ; d4 = d2 & 55555555
  255. ; d4 = ..............a1 ..c1..e1..g1..b1 ..d1..f1..h1..a3 ..c3..e3..g3....
  256.  
  257.         move.l    d2,d4        ;  4
  258.         and.l    d6,d4        ;  8 d6=$55555555
  259.  
  260. ; d2 ^= d4
  261. ; d2 = ................ a0..c0..e0..g0.. b0..d0..f0..h0.. a2..c2..e2..g2..
  262.  
  263.         eor.l    d4,d2        ;  8
  264.  
  265. ; d3 = (d3 | d4) >> 1
  266. ; d3 = ................ a1b1c1d1e1f1g1h1 ................ a3b3c3d3e3f3g3h3
  267.  
  268.         or.l    d4,d3        ;  8
  269.         lsr.l    #1,d3        ; 10
  270.  
  271.         move.b    d3,(4,a4)    ; 12 plane 3
  272.         swap    d3        ;  4
  273.         move.b    d3,(4,a3)    ; 12 plane 1
  274.  
  275. ; d2 = d2 | d0
  276. ; d2 = ................ a0b0c0d0e0f0g0h0 ................ a2b2c2d2e2f2g2h2
  277.  
  278.         or.l    d0,d2        ;  8
  279.  
  280.         move.b    d2,(a4)+    ;  8 plane 2
  281.         swap    d2        ;  4
  282.         move.b    d2,(a3)+    ;  8 plane 0
  283.  
  284. ; test if stack buffers are full, loop back if not
  285.  
  286.         cmpa.l    a3,a2        ;  6
  287.         bne.w    mainloop    ; 10    total=540 (67.5 cycles/pixel)
  288.  
  289. ; move stack buffers to bitplanes (longword writes) and restore ptrs
  290.  
  291.     iflt 4*plsiz-4-32768            ; a1 points into plane 3
  292.         move.l    (a4),(a1)+        ; plane 3
  293.         move.l    (a6),(4*plsiz-4,a1)    ; plane 7
  294.         move.l    -(a6),(3*plsiz-4,a1)    ; plane 6
  295.         move.l    (a5),(2*plsiz-4,a1)    ; plane 5
  296.         move.l    -(a5),(1*plsiz-4,a1)    ; plane 4
  297.         move.l    -(a4),(-1*plsiz-4,a1)    ; plane 2
  298.         move.l    (a3),(-2*plsiz-4,a1)    ; plane 1
  299.         move.l    -(a3),(-3*plsiz-4,a1)    ; plane 0
  300.     else
  301.     iflt 2*plsiz-4-32768            ; a1 points into plane 1
  302.         move.l    (a3),(a1)+        ; plane 1
  303.         adda.l    #4*plsiz,a1
  304.         move.l    (a6),(2*plsiz-4,a1)    ; plane 7
  305.         move.l    -(a6),(1*plsiz-4,a1)    ; plane 6
  306.         move.l    (a5),(0*plsiz-4,a1)    ; plane 5
  307.         move.l    -(a5),(-1*plsiz-4,a1)    ; plane 4
  308.         suba.l    #4*plsiz,a1
  309.         move.l    (a4),(2*plsiz-4,a1)    ; plane 3
  310.         move.l    -(a4),(1*plsiz-4,a1)    ; plane 2
  311.         move.l    -(a3),(-1*plsiz-4,a1)    ; plane 0
  312.     else
  313.     iflt plsiz-32768            ; a1 points into plane 0
  314.         adda.l    #6*plsiz,a1
  315.         move.l    (a6),(plsiz,a1)        ; plane 7
  316.         move.l    -(a6),(a1)        ; plane 6
  317.         move.l    (a5),(-plsiz,a1)    ; plane 5
  318.         suba.l    #3*plsiz,a1
  319.         move.l    -(a5),(plsiz,a1)    ; plane 4
  320.         move.l    (a4),(a1)        ; plane 3
  321.         move.l    -(a4),(-plsiz,a1)    ; plane 2
  322.         suba.l    #3*plsiz,a1
  323.         move.l    (a3),(plsiz,a1)        ; plane 1
  324.         move.l    -(a3),(a1)+        ; plane 0
  325.     else
  326.         move.l    #plsiz,d0        ; a1 points into plane 0
  327.         adda.l    #7*plsiz,a1
  328.         move.l    (a6),(a1)        ; plane 7
  329.         suba.l    d0,a1
  330.         move.l    -(a6),(a1)        ; plane 6
  331.         suba.l    d0,a1
  332.         move.l    (a5),(a1)        ; plane 5
  333.         suba.l    d0,a1
  334.         move.l    -(a5),(a1)        ; plane 4
  335.         suba.l    d0,a1
  336.         move.l    (a4),(a1)        ; plane 3
  337.         suba.l    d0,a1
  338.         move.l    -(a4),(a1)        ; plane 2
  339.         suba.l    d0,a1
  340.         move.l    (a3),(a1)        ; plane 1
  341.         suba.l    d0,a1
  342.         move.l    -(a3),(a1)+        ; plane 0
  343.     endc
  344.     endc
  345.     endc
  346.  
  347. ; check if finished, go back for more
  348.  
  349.         sub.w    #1,(sp)
  350.         bne.w    mainloop
  351.  
  352. ; CPU all done!  restore stack
  353.  
  354.         addq.w    #2,sp            ; remove outer loop counter
  355.  
  356. ; find out how long it took
  357.  
  358.         lea    (endcputime-buffers,a3),a0
  359.         movea.l    (timerbase-buffers,a3),a6    ; timerbase
  360.         jsr    (_LVOReadEClock,a6)
  361.  
  362. ; wait for the blitter to finish
  363. ; busy-wait (for a very short time) on FAST bus, even on a CHIP-only machine
  364.  
  365.         movea.l    (gfxbase-buffers,a3),a6
  366.         bra.b    endwaitloop
  367. waitloop:    jsr    (_LVOWaitBlit,a6)
  368. endwaitloop:    tst.b    (waitflag-buffers,a3)
  369.         bne.b    waitloop
  370.  
  371. ; get blittime,cputime,n_blit in d2,d3,d0
  372.  
  373.         move.l    (endblittime+4-buffers,a3),d2
  374.         sub.l    (starttime+4-buffers,a3),d2
  375.  
  376.         move.l    (endcputime+4-buffers,a3),d3
  377.         sub.l    (starttime+4-buffers,a3),d3
  378.  
  379.         move.l    (n_blit-buffers,a3),d0
  380.  
  381. ; branch if this is not the first time through
  382.  
  383.         bset    #0,(firsttimeflag-buffers,a3)
  384.         bne.b    simple
  385.  
  386. ; calculate new partition point for next call using formula
  387.  
  388.         moveq    #10,d4
  389.         lsr.l    d4,d2            ; scale t_blit (avoid overflow)
  390.         lsr.l    d4,d3            ; scale t_cpu
  391.         lsr.l    #4,d0            ; scale n_blit
  392.         mulu    d0,d3            ; d3 = n_blit*t_cpu
  393.         move.w    #(pixels/32)>>4,d1    ; n (scaled)
  394.         sub.w    d0,d1
  395.         mulu    d2,d1            ; d1 = (n-n_blit)*t_blit
  396.         add.w    d3,d1
  397.         beq.b    alldone            ; never divide by 0!
  398.         mulu    #(pixels/32)>>4,d3    ; n (scaled)
  399.         divu    d1,d3
  400.         moveq    #0,d0
  401.         move.w    d3,d0
  402.         lsl.l    #4,d0            ; scale back n_blit
  403.         bra.b    done
  404.  
  405. ; simple-minded adjustment
  406.  
  407. simple:        sub.l    d3,d2            ; blittime-cputime
  408.         beq.b    alldone            ; can't do better than this
  409.         bgt.b    1$
  410. ; blittime < cputime, increase n_blit
  411.         addq.l    #8,d0
  412.         cmp.l    #pixels/32,d0
  413.         bcs.b    done
  414.         bra.b    alldone            ; don't go out of range
  415. ; blittime > cputime, decrease n_blit
  416. 1$:        subq.l    #8,d0
  417.         bhi.b    done
  418.         bra.b    alldone            ; don't go out of range
  419.  
  420. ; save the new partition point
  421.  
  422. done:        move.l    d0,(n_blit-buffers,a3)
  423.         lsl.l    #2,d0
  424.         move.l    d0,(plsiz_blit-buffers,a3)
  425.         lsl.l    #3,d0
  426.         move.l    d0,(pixels_blit-buffers,a3)
  427.  
  428. ; all done!
  429.  
  430. alldone:    movem.l    (sp)+,d2-d7/a2-a6
  431.         rts
  432.  
  433. ;-----------------------------------------------------------------------------
  434. ; QBlit functions (called asynchronously)
  435.  
  436. blit11:        moveq    #-1,d0
  437.         move.l    d0,(bltafwm,a0)
  438.         move.l    #(8<<16)+8,(bltbmod,a0)    ; also loads bltamod
  439.         move.w    #0,(bltdmod,a0)
  440.         move.l    #buff0,(bltapt,a0)    ; buff0
  441.         move.l    #buff0+8,(bltbpt,a0)    ; buff0+8
  442.         move.w    #%1111111100000000,(bltcdat,a0)
  443.         move.l    #buff1,(bltdpt,a0)    ; buff1
  444.         move.l    #$0DE48000,(bltcon0,a0)    ; D=AC+(B>>8)~C
  445.         move.l    (pixels_blit-mybltnode,a1),d0
  446.         lsr.l    #4,d0
  447.         move.w    d0,(bltsizv,a0)        ; pixels_blit/16
  448.         move.w    #4,(bltsizh,a0)        ; do blit
  449.         lea    (blit12,pc),a0
  450.         move.l    a0,(qblitfunc-mybltnode,a1)
  451.         rts
  452.  
  453. blit12:        move.l    #buff0,d0
  454.         add.l    (pixels_blit-mybltnode,a1),d0
  455.         sub.l    #8+2,d0
  456.         move.l    d0,(bltapt,a0)        ; buff0+pixels_blit-8-2
  457.         addq.l    #8,d0
  458.         move.l    d0,(bltbpt,a0)        ; buff0+pixels_blit-2
  459.         add.l    #buff1-buff0,d0
  460.         move.l    d0,(bltdpt,a0)        ; buff1+pixels_blit-2
  461.         move.l    #$8DE40002,(bltcon0,a0)    ; D=(A<<8)C+B~C, desc.
  462.         move.w    #4,(bltsizh,a0)        ; do blit
  463.         lea    (blit21,pc),a0
  464.         move.l    a0,(qblitfunc-mybltnode,a1)
  465.         rts
  466.  
  467. blit21:        move.l    #(4<<16)+4,(bltbmod,a0)    ; also load bltamod
  468.         move.l    #buff1,(bltapt,a0)
  469.         move.l    #buff1+4,(bltbpt,a0)
  470.         move.w    #%1111000011110000,(bltcdat,a0)
  471.         move.l    #buff0,(bltdpt,a0)
  472.         move.l    #$0DE44000,(bltcon0,a0)    ; D=AC+(B>>4)~C
  473.         move.l    (pixels_blit-mybltnode,a1),d0
  474.         lsr.l    #3,d0
  475.         move.w    d0,(bltsizv,a0)        ; pixels_blit/8
  476.         move.w    #2,(bltsizh,a0)        ; do blit
  477.         lea    (blit22,pc),a0
  478.         move.l    a0,(qblitfunc-mybltnode,a1)
  479.         rts
  480.  
  481. blit22:        move.l    #buff1,d0
  482.         add.l    (pixels_blit-mybltnode,a1),d0
  483.         subq.l    #2+4,d0
  484.         move.l    d0,(bltapt,a0)        ; buff1+pixels_blit-2-4
  485.         addq.l    #4,d0
  486.         move.l    d0,(bltbpt,a0)        ; buff1+pixels_blit-2
  487.         add.l    #buff0-buff1,d0
  488.         move.l    d0,(bltdpt,a0)        ; buff0+pixels_blit-2
  489.         move.l    #$4DE40002,(bltcon0,a0)    ; D=(A<<4)C+B~C, desc.
  490.         move.w    #2,(bltsizh,a0)        ; do blit
  491.         lea    (blit31,pc),a0
  492.         move.l    a0,(qblitfunc-mybltnode,a1)
  493.         rts
  494.  
  495. blit31:        move.l    #(2<<16)+2,(bltbmod,a0)    ; also load bltamod
  496.         move.l    #buff0,(bltapt,a0)
  497.         move.l    #buff0+2,(bltbpt,a0)
  498.         move.w    #%1100110011001100,(bltcdat,a0)
  499.         move.l    #buff1,(bltdpt,a0)
  500.         move.l    (pixels_blit-mybltnode,a1),d0
  501.         lsr.l    #2,d0
  502.         move.w    d0,(bltsizv,a0)        ; pixels_blit/4
  503.         move.l    #$0DE42000,(bltcon0,a0)    ; D=AC+(B>>2)~C
  504.         move.w    #1,(bltsizh,a0)        ; do blit
  505.         lea    (blit32,pc),a0
  506.         move.l    a0,(qblitfunc-mybltnode,a1)
  507.         rts
  508.  
  509. blit32:        move.l    #buff0,d0
  510.         add.l    (pixels_blit-mybltnode,a1),d0
  511.         subq.l    #2+2,d0
  512.         move.l    d0,(bltapt,a0)        ; buff0+pixels_blit-2-2
  513.         addq.l    #2,d0
  514.         move.l    d0,(bltbpt,a0)        ; buff0+pixels_blit-2
  515.         add.l    #buff1-buff0,d0
  516.         move.l    d0,(bltdpt,a0)        ; buff1+pixels_blit-2
  517.         move.l    #$2DE40002,(bltcon0,a0)    ; D=(A<<2)C+B~C, desc.
  518.         move.w    #1,(bltsizh,a0)        ; do blit
  519.         lea    (blit41,pc),a0
  520.         move.l    a0,(qblitfunc-mybltnode,a1)
  521.         rts
  522.  
  523. blit41:        moveq    #0,d0
  524.         move.l    d0,(bltbmod,a0)        ; also load bltamod
  525.         move.l    #buff1,d0
  526.         move.l    d0,(bltapt,a0)        ; buff1+0*plsiz_blit
  527.         add.l    (plsiz_blit-mybltnode,a1),d0
  528.         move.l    d0,(bltbpt,a0)        ; buff1+1*plsiz_blit
  529.         move.l    d0,(tmp_ptr-mybltnode,a1)
  530.         move.w    #%1010101010101010,(bltcdat,a0)
  531.         move.l    (plane0-mybltnode,a1),d0
  532.         add.l    #7*plsiz,d0
  533.         move.l    d0,(bltdpt,a0)        ; Plane7
  534.         move.l    (pixels_blit-mybltnode,a1),d0
  535.         lsr.l    #4,d0
  536.         move.w    d0,(bltsizv,a0)        ; pixels_blit/16
  537.         move.l    #$0DE41000,(bltcon0,a0)    ; D=AC+(B>>1)~C
  538.         move.w    #1,(bltsizh,a0)        ; do blit
  539.         lea    (blit42,pc),a0
  540.         move.l    a0,(qblitfunc-mybltnode,a1)
  541.         rts
  542.  
  543. blit42:        move.l    (plsiz_blit-mybltnode,a1),d1
  544.         move.l    (tmp_ptr-mybltnode,a1),d0
  545.         add.l    d1,d0
  546.         move.l    d0,(bltapt,a0)        ; buff1+2*plsiz_blit
  547.         add.l    d1,d0
  548.         move.l    d0,(bltbpt,a0)        ; buff1+3*plsiz_blit
  549.         move.l    d0,(tmp_ptr-mybltnode,a1)
  550.         move.l    (plane0-mybltnode,a1),d0
  551.         add.l    #3*plsiz,d0
  552.         move.l    d0,(bltdpt,a0)        ; Plane3
  553.         move.w    #1,(bltsizh,a0)        ; do blit
  554.         lea    (blit43,pc),a0
  555.         move.l    a0,(qblitfunc-mybltnode,a1)
  556.         rts
  557.  
  558. blit43:        move.l    (plsiz_blit-mybltnode,a1),d1
  559.         move.l    (tmp_ptr-mybltnode,a1),d0
  560.         add.l    d1,d0
  561.         move.l    d0,(bltapt,a0)        ; buff1+4*plsiz_blit
  562.         add.l    d1,d0
  563.         move.l    d0,(bltbpt,a0)        ; buff1+5*plsiz_blit
  564.         move.l    d0,(tmp_ptr-mybltnode,a1)
  565.         move.l    (plane0-mybltnode,a1),d0
  566.         add.l    #5*plsiz,d0
  567.         move.l    d0,(bltdpt,a0)        ; Plane5
  568.         move.w    #1,(bltsizh,a0)        ;do blit
  569.         lea    (blit44,pc),a0
  570.         move.l    a0,(qblitfunc-mybltnode,a1)
  571.         rts
  572.  
  573. blit44:        move.l    (plsiz_blit-mybltnode,a1),d1
  574.         move.l    (tmp_ptr-mybltnode,a1),d0
  575.         add.l    d1,d0
  576.         move.l    d0,(bltapt,a0)        ; buff1+6*plsiz_blit
  577.         add.l    d1,d0
  578.         move.l    d0,(bltbpt,a0)        ; buff1+7*plsiz_blit
  579.         move.l    d0,(tmp_ptr-mybltnode,a1)
  580.         move.l    (plane0-mybltnode,a1),d0
  581.         add.l    #1*plsiz,d0
  582.         move.l    d0,(bltdpt,a0)        ; Plane1
  583.         move.w    #1,(bltsizh,a0)        ; do blit
  584.         lea    (blit45,pc),a0
  585.         move.l    a0,(qblitfunc-mybltnode,a1)
  586.         rts
  587.  
  588. blit45:        move.l    (plsiz_blit-mybltnode,a1),d1
  589.         move.l    (tmp_ptr-mybltnode,a1),d0
  590.         add.l    d1,d0
  591.         subq.l    #2,d0
  592.         move.l    d0,(bltbpt,a0)        ; buff1+8*plsiz_blit-2
  593.         sub.l    d1,d0
  594.         move.l    d0,(bltapt,a0)        ; buff1+7*plsiz_blit-2
  595.         move.l    d0,(tmp_ptr-mybltnode,a1)
  596.         move.l    (plane0-mybltnode,a1),d0
  597.         add.l    d1,d0
  598.         subq.l    #2,d0
  599.         move.l    d0,(bltdpt,a0)        ; Plane0
  600.         move.l    #$1DE40002,(bltcon0,a0)    ; D=(A<<1)C+B~C, desc.
  601.         move.w    #1,(bltsizh,a0)        ; do blit
  602.         lea    (blit46,pc),a0
  603.         move.l    a0,(qblitfunc-mybltnode,a1)
  604.         rts
  605.  
  606. blit46:        move.l    (plsiz_blit-mybltnode,a1),d1
  607.         move.l    (tmp_ptr-mybltnode,a1),d0
  608.         sub.l    d1,d0
  609.         move.l    d0,(bltbpt,a0)        ; buff1+6*plsiz_blit-2
  610.         sub.l    d1,d0
  611.         move.l    d0,(bltapt,a0)        ; buff1+5*plsiz_blit-2
  612.         move.l    d0,(tmp_ptr-mybltnode,a1)
  613.         move.l    (plane0-mybltnode,a1),d0
  614.         add.l    #4*plsiz-2,d0
  615.         add.l    d1,d0
  616.         move.l    d0,(bltdpt,a0)        ; Plane4
  617.         move.w    #1,(bltsizh,a0)        ; do blit
  618.         lea    (blit47,pc),a0
  619.         move.l    a0,(qblitfunc-mybltnode,a1)
  620.         rts
  621.  
  622. blit47:        move.l    (plsiz_blit-mybltnode,a1),d1
  623.         move.l    (tmp_ptr-mybltnode,a1),d0
  624.         sub.l    d1,d0
  625.         move.l    d0,(bltbpt,a0)        ; buff1+4*plsiz_blit-2
  626.         sub.l    d1,d0
  627.         move.l    d0,(bltapt,a0)        ; buff1+3*plsiz_blit-2
  628.         move.l    d0,(tmp_ptr-mybltnode,a1)
  629.         move.l    (plane0-mybltnode,a1),d0
  630.         add.l    #2*plsiz-2,d0
  631.         add.l    d1,d0
  632.         move.l    d0,(bltdpt,a0)        ; Plane2
  633.         move.w    #1,(bltsizh,a0)        ; do blit
  634.         lea    (blit48,pc),a0
  635.         move.l    a0,(qblitfunc-mybltnode,a1)
  636.         rts
  637.  
  638. blit48:        move.l    (plsiz_blit-mybltnode,a1),d1
  639.         move.l    (tmp_ptr-mybltnode,a1),d0
  640.         sub.l    d1,d0
  641.         move.l    d0,(bltbpt,a0)        ; buff1+2*plsiz_blit-2
  642.         sub.l    d1,d0
  643.         move.l    d0,(bltapt,a0)        ; buff1+1*plsiz_blit-2
  644.         move.l    (plane0-mybltnode,a1),d0
  645.         add.l    #6*plsiz-2,d0
  646.         add.l    d1,d0
  647.         move.l    d0,(bltdpt,a0)        ; Plane6
  648.         move.w    #1,(bltsizh,a0)        ; do blit
  649.         lea    (blit11,pc),a0
  650.         move.l    a0,(qblitfunc-mybltnode,a1)
  651.         moveq    #0,d0            ; set Z flag
  652.         rts
  653.  
  654. qblitcleanup:    movem.l    a2/a6,-(sp)
  655.         move.l    #mybltnode,a2
  656.         lea    (endblittime-mybltnode,a2),a0
  657.         move.l    (timerbase-mybltnode,a2),a6
  658.         jsr    (_LVOReadEClock,a6)    ; may be called from interrupts
  659.         sf    (waitflag-mybltnode,a2)
  660.         movem.l    (sp)+,a2/a6
  661.         rts
  662.  
  663. ;-----------------------------------------------------------------------------
  664.  
  665.         section    data,data
  666.  
  667.         quad
  668. buffers:    dc.l    0,0,0,0,0,0,0,0
  669. mybltnode:    dc.l    0        ; next bltnode
  670. qblitfunc:    dc.l    blit11        ; ptr to qblitfunc()
  671.         dc.b    cleanup        ; stat
  672.         dc.b    0        ; filler
  673.         dc.w    0        ; blitsize
  674.         dc.w    0        ; beamsync
  675.         dc.l    qblitcleanup    ; ptr to qblitcleanup()
  676.  
  677.         quad
  678. chunky:        dc.l    0        ; ptr to original chunky data
  679. plane0:        dc.l    0        ; ptr to output planes
  680. pixels_blit:    dc.l    pixels/2    ; number of pixels handled by blitter
  681. plsiz_blit:    dc.l    pixels/8/2    ; & corresponding (partial) planesize
  682. n_blit:        dc.l    pixels/32/2    ; number of 32-byte units for blitter
  683. tmp_ptr:    dc.l    0
  684. gfxbase:    dc.l    0
  685. timerbase:    dc.l    0
  686. starttime:    dc.l    0,0
  687. endblittime:    dc.l    0,0
  688. endcputime:    dc.l    0,0
  689. waitflag:    dc.b    0
  690. firsttimeflag:    dc.b    0
  691.  
  692. ;-----------------------------------------------------------------------------
  693.  
  694.         section    bss,bss,chip    ; MUST BE IN CHIP !!!!!
  695.  
  696.         quad
  697. buff0:        ds.b    pixels        ;Intermediate buffer 1
  698. buff1:        ds.b    pixels        ;Intermediate buffer 1
  699.  
  700. ;-----------------------------------------------------------------------------
  701.  
  702.         end
  703.